/**   
 * @ClassName: MenuServiceImpl.java 
 * @Package com.vrv.menu.service.impl 
 * @author LQ   
 * @date 2017年3月12日 下午5:10:50 
 * @version V1.0
 */
package com.vrv.menu.service.impl;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.github.pagehelper.PageHelper;
import com.vrv.common.constants.Constants;
import com.vrv.common.util.result.ResultMapper;
import com.vrv.menu.dao.MenuDao;
import com.vrv.menu.model.Menu;
import com.vrv.menu.service.MenuService;

/** 
 * MenuServiceImpl:菜单service实现类
 * @author LQ 
 */
@Service("menuService")
public class MenuServiceImpl implements MenuService {
    
    /**
     * 菜单dao注入
     */
    @Autowired(required=true)
    private MenuDao menuDao;
    
    /**
     * 菜单集合
     * @return List<Menu> 菜单集合 
     */
    @Override
    public List<Menu> list() {
        Map<String, Object> params = new HashMap<String, Object>();
        List<Menu> list = this.menuDao.list(params);
        return list;
    }
    
    /**
     * 菜单集合分页
     * @param page 页
     * @param rows 行
     * @return List<Menu> 菜单集合 
     */
    @Override
    public List<Menu> list(Integer page, Integer limit) {
        //分页插件设置参数
        PageHelper.startPage(page,limit);
        Map<String, Object> params = new HashMap<String, Object>();
        List<Menu> list = this.menuDao.list(params);
        return list;
    }

    /**
     * 根据用户查询菜单
     * @param userCode 用户编号
     * @return List<Menu> 菜单集合
     */
    @Override
    public List<Menu> queryUserMenuList(Integer userCode) {
        //系统管理员，拥有最高权限
        if(userCode.equals(Constants.ADMIN)){
            return queryAllMenuList(null);
        }
        return null;
    }
    
    /**
     * 根据菜单编号集合查询菜单
     * @param menuCodeList 菜单编号集合
     * @return List<Menu> 菜单集合
     */
    private List<Menu> queryAllMenuList(List<Integer> menuCodeList){
        //查询根菜单列表
        List<Menu> menuList = queryMenuByParentCodeList(Constants.ROOT_CODE, menuCodeList);
        //递归获取子菜单
        queryMenuTreeList(menuList, menuCodeList);
        return menuList;
    }

    /**
     * 根据父项编号查询菜单集合
     * @param parentCode 父项编号
     * @return List<Menu> 菜单集合
     */
    @Override
    public List<Menu> queryMenuByParentCodeList(Integer parentCode,List<Integer> menuCodeList) {
        List<Menu> menuList = menuDao.queryMenuByParentCodeList(parentCode);
        if(menuCodeList == null){
            return menuList;
        }
        List<Menu> userMenuList = new ArrayList<>();
        
        for(Menu menu : menuList){
            if(menuCodeList.contains(menu.getMenuCode())){
                userMenuList.add(menu);
            }
        }
        
        return userMenuList;
    }
    
    /**
     * 递归返回菜单集合
     * @param menuList 菜单集合
     * @param menuCodeList 菜单编号集合
     * @return List<Menu> 菜单集合
     */
    private List<Menu> queryMenuTreeList(List<Menu> menuList, List<Integer> menuCodeList){
        List<Menu> subMenuList = new ArrayList<Menu>();
        for(Menu entity : menuList){
            if(entity.getIsLeaf().equals(Constants.ISLEAF_NO)){//不是叶子节点
                entity.setList(queryMenuTreeList(queryMenuByParentCodeList(entity.getMenuCode(), menuCodeList), menuCodeList));
            }
            subMenuList.add(entity);
        }
        return subMenuList;
    }
    
    /**
     * 根据菜单编号查询菜单实体
     * @param menuCode 菜单编号
     * @return Menu 菜单实体
     */
    @Override
    public Menu getMenuByCode(Integer menuCode) {
        return menuDao.getMenuByCode(menuCode);
    }
    
    /**
     * 新增菜单
     * @param menu 菜单实体
     */
    @Override
    public void add(Menu menu) {
        //如果是一级菜单
        if(menu.getParentCode().equals(Constants.ROOT_CODE)){
            //设置treepath路径
            menu.setTreePath(Constants.ROOT_TREEPATH);
            menu.setMenuLevel(Constants.DEFAULT_LEVEL);
        }else{
            //获取父项菜单
            Menu parentMenu = this.menuDao.getMenuByCode(menu.getParentCode());
            menu.setTreePath(parentMenu.getTreePath()+menu.getParentCode()+Constants.SEPARATOR_COMMA);
            menu.setMenuLevel(parentMenu.getMenuLevel()+Constants.DIGIT_1);
            //如果父项为叶子节点，改为父节点
            if(parentMenu.getIsLeaf().equals(Constants.ISLEAF_YES) ){
                parentMenu.setIsLeaf(Constants.ISLEAF_NO);
                this.menuDao.update(parentMenu);
            }
        }
        menu.setIsDelete(Constants.ISDELETE_NO);
        menu.setIsEnable(Constants.ISENABLE_YES);
        menu.setIsLeaf(Constants.ISLEAF_YES);
        this.menuDao.add(menu);
    }
    
    /**
     * 修改菜单
     * @param menu 菜单实体
     */
    @Override
    public void update(Menu menu) {
        //获取原始的菜单
        Menu originalMenu = menuDao.getMenuByCode(menu.getMenuCode());
        //父项菜单发生变化时更新
        if(!originalMenu.getParentCode().equals(menu.getParentCode()) ){
            //获取父项菜单
            Menu parentMenu = menuDao.getMenuByCode(menu.getParentCode());
            //级别差
            Integer level = Constants.DEFAULT_INTEGER;
            String nowTreePath = Constants.DEFAULT_STRING;
            String originalTreePath = originalMenu.getTreePath();
            //如果原来菜单的父项菜单不为一级菜单时
            if(!originalMenu.getParentCode().equals(Constants.ROOT_CODE)){
                //判断原来父项菜单下面是否还有子菜单,如果有不做任何设置，没有则将原有菜单的是否叶子节点设置为1
                Integer childrenCount = menuDao.getChildrenTotal(originalMenu.getParentCode());
                Menu originalParentMenu = menuDao.getMenuByCode(originalMenu.getParentCode());
                if(childrenCount-Constants.DIGIT_1 < Constants.DIGIT_1){
                    originalParentMenu.setIsLeaf(Constants.ISLEAF_YES);
                    menuDao.update(originalParentMenu);
                }
                
            }
            //现在菜单为一级菜单时
            if(parentMenu == null){
                level = originalMenu.getMenuLevel()-Constants.DIGIT_1;
                nowTreePath = Constants.ROOT_TREEPATH;
            }else{
                level = originalMenu.getMenuLevel() - (parentMenu.getMenuLevel() + Constants.DIGIT_1);
                nowTreePath = parentMenu.getTreePath()+parentMenu.getMenuCode()+Constants.SEPARATOR_COMMA;
                //判断现在的父项菜单是否为叶子节点
                if(parentMenu.getIsLeaf().equals(Constants.ISLEAF_YES)){
                    parentMenu.setIsLeaf(Constants.ISLEAF_NO);
                    menuDao.update(parentMenu);
                }
            }
            menuDao.updateLevel(level, originalMenu.getTreePath()+menu.getMenuCode()+Constants.SEPARATOR_COMMA);
            menuDao.updateTreePath(nowTreePath+menu.getMenuCode()+Constants.SEPARATOR_COMMA , 
                    originalTreePath+menu.getMenuCode()+Constants.SEPARATOR_COMMA);
            //修改菜单自身
            menu.setMenuLevel(originalMenu.getMenuLevel() - level);
            menu.setTreePath(nowTreePath);
        }
        menuDao.update(menu);
    }

    /**
     * 批量删除
     * @param menuCodes 主键数组
     * @return ResultMapper
     */
    @Override
    public ResultMapper deleteBatch(Integer[] menuCodes) {
        for(Integer menuCode : menuCodes){
            if(menuCode.intValue() <= 1006){
                return ResultMapper.error("系统菜单，不能删除！");
            }
        }
        for(Integer menuCode : menuCodes){
            Menu menu = menuDao.getMenuByCode(menuCode);
            menuDao.deleteByCode(menuCode);
            menuDao.delete(menu.getTreePath()+menuCode+Constants.SEPARATOR_COMMA);
            if(menu.getParentCode().equals(Constants.ROOT_CODE)){
                continue;
            }else{
                Integer childrenCount = menuDao.getChildrenTotal(menu.getParentCode());
                if(childrenCount-Constants.DIGIT_1 < Constants.DIGIT_1){
                    Menu parentMenu = menuDao.getMenuByCode(menu.getParentCode());
                    parentMenu.setIsLeaf(Constants.ISLEAF_YES);
                    menuDao.update(parentMenu);
                }
                menuDao.delete(menu.getTreePath());
            }
        }
        return ResultMapper.ok(Constants.RESULT_MESSAGE_DELETE_SUCCESS);
    }

}
